﻿//#include "Character_Process.h"
//
//static const uint8_t s_CRCHi[] = {
//    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
//    0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
//    0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
//    0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
//    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
//    0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
//    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
//    0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
//    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
//    0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40,
//    0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
//    0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
//    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
//    0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40,
//    0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
//    0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
//    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
//    0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
//    0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
//    0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
//    0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
//    0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40,
//    0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
//    0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
//    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
//    0x80, 0x41, 0x00, 0xC1, 0x81, 0x40
//};
//// CRC 低位字节值表
//const uint8_t s_CRCLo[] = {
//    0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06,
//    0x07, 0xC7, 0x05, 0xC5, 0xC4, 0x04, 0xCC, 0x0C, 0x0D, 0xCD,
//    0x0F, 0xCF, 0xCE, 0x0E, 0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09,
//    0x08, 0xC8, 0xD8, 0x18, 0x19, 0xD9, 0x1B, 0xDB, 0xDA, 0x1A,
//    0x1E, 0xDE, 0xDF, 0x1F, 0xDD, 0x1D, 0x1C, 0xDC, 0x14, 0xD4,
//    0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 0x12, 0x13, 0xD3,
//    0x11, 0xD1, 0xD0, 0x10, 0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3,
//    0xF2, 0x32, 0x36, 0xF6, 0xF7, 0x37, 0xF5, 0x35, 0x34, 0xF4,
//    0x3C, 0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A,
//    0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38, 0x28, 0xE8, 0xE9, 0x29,
//    0xEB, 0x2B, 0x2A, 0xEA, 0xEE, 0x2E, 0x2F, 0xEF, 0x2D, 0xED,
//    0xEC, 0x2C, 0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26,
//    0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0, 0xA0, 0x60,
//    0x61, 0xA1, 0x63, 0xA3, 0xA2, 0x62, 0x66, 0xA6, 0xA7, 0x67,
//    0xA5, 0x65, 0x64, 0xA4, 0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F,
//    0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 0x68,
//    0x78, 0xB8, 0xB9, 0x79, 0xBB, 0x7B, 0x7A, 0xBA, 0xBE, 0x7E,
//    0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C, 0xB4, 0x74, 0x75, 0xB5,
//    0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71,
//    0x70, 0xB0, 0x50, 0x90, 0x91, 0x51, 0x93, 0x53, 0x52, 0x92,
//    0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54, 0x9C, 0x5C,
//    0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E, 0x5A, 0x9A, 0x9B, 0x5B,
//    0x99, 0x59, 0x58, 0x98, 0x88, 0x48, 0x49, 0x89, 0x4B, 0x8B,
//    0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C,
//    0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42,
//    0x43, 0x83, 0x41, 0x81, 0x80, 0x40
//};
//
//const temp_table table[] = {
//    {794, 25861, 15},
//    {806, 25259, 16},
//    {832, 24093, 17},
//    {874, 23508, 18},
//    {900, 22503, 19},
//    {931, 22204, 20},
//    {962, 21162, 21},
//    {960, 21161, 22},
//    {992, 20582, 23},
//    {1006, 20449, 24},
//    {1037, 19584, 25},
//    {1088, 18815, 26},
//    {1090, 18782, 27},
//    {1122, 18305, 28},
//    {1152, 17469, 29},
//    {1167, 17518, 30},
//    {1191, 17196, 31},
//    {1236, 16459, 32},
//    {1235, 16462, 33},
//    {1282, 15810, 34},
//    {1312, 15713, 35},
//    {1336, 15310, 36},
//    {1372, 15030, 37},
//    {1397, 14604, 38},
//    {1448, 14244, 39},
//    {1442, 14113, 40},
//    {1460, 13930, 41},
//    {1496, 13678, 42},
//    {1528, 13374, 43},
//    {1557, 12874, 44},
//    {1570, 12889, 45},
//    {1622, 12440, 46},
//    {1648, 12508, 47},
//    {1650, 12430, 48},
//    {1735, 11760, 49},
//    {1733, 11760, 50},
//    {1735, 11759, 51},
//    {1760, 11687, 52},
//    {1794, 11423, 53},
//    {1822, 11291, 54},
//    {1853, 10785, 55},
//    {1880, 10879, 56},
//    {1900, 10833, 57},
//    {1927, 10557, 58},
//    {1940, 10332, 59},
//    {1966, 10351, 60},
//    {1996, 10362, 61},
//    {2009, 10108, 62},
//    {2033, 9991, 63},
//    {2061, 9837, 64},
//    {2078, 9852, 65},
//    {2100, 9759, 66},
//    {2125, 9553, 67},
//    {2166, 9405, 68},
//    {2162, 9405, 69},
//    {2183, 9346, 70},
//    {2206, 9246, 71},
//    {2232, 9149, 72},
//    {2253, 9024, 73},
//    {2270, 8951, 74},
//    {2275, 8947, 75},
//    {2308, 8851, 76},
//    {2311, 8823, 77},
//    {2338, 8771, 78},
//    {2356, 8677, 79},
//    {2367, 8556, 80},
//    {2374, 8509, 81},
//    {2401, 8500, 82},
//    {2428, 8439, 83},
//    {2438, 8123, 84},
//    {2466, 8314, 85},
//    {2466, 8314, 86},
//    {2474, 8194, 87},
//    {2498, 7955, 88},
//    {2508, 8147, 89},
//    {2529, 8097, 90},
//    {2541, 7847, 91},
//    {2554, 8014, 92},
//    {2560, 7766, 93},
//    {2579, 7881, 94},
//    {2592, 7854, 95},
//    {2602, 7793, 96},
//    {2612, 7826, 97},
//    {2613, 7820, 98},
//    {2613, 7760, 99},
//    {2618, 7751, 100},
//    {2640, 7749, 101},
//    {2658, 7689, 102},
//    {2675, 7626, 103},
//    {2701, 7603, 104},
//    {2699, 7603, 105}
//};
//
//// 表格大小
//#define TABLE_SIZE (sizeof(table)/sizeof(table[0]))
//
///* 根据 ADC 值获取温度 */
//float get_temperature_by_adc(uint32_t adc) {
//    int i;
//    float temp;
//
//    /* 确保 ADC 值在合理范围内 */
//    if (adc < table[0].adcVal || adc > table[TABLE_SIZE - 1].adcVal) {
//        return -999.0f; /* 错误值 */
//    }
//
//    /* 遍历查找表 */
//    for (i = 0; i < TABLE_SIZE; i++) {
//        if (table[i].adcVal == adc) {
//            return table[i].tempVal;
//        }
//    }
//
//    /* 如果 ADC 值不在表中，返回最近的温度值 */
//    for (i = 0; i < TABLE_SIZE - 1; i++) {
//        if (adc > table[i].adcVal && adc < table[i + 1].adcVal) {
//            /* 线性插值 */
//            float delta_adc = table[i + 1].adcVal - table[i].adcVal;
//            float delta_temp = table[i + 1].tempVal - table[i].tempVal;
//            temp = table[i].tempVal + (adc - table[i].adcVal) * delta_temp / delta_adc;
//            return temp;
//        }
//    }
//
//    /* 如果超出表格范围，返回边界值 */
//    if (adc <= table[0].adcVal) {
//        return table[0].tempVal;
//    }
//    if (adc >= table[TABLE_SIZE - 1].adcVal) {
//        return table[TABLE_SIZE - 1].tempVal;
//    }
//
//    return -999.0f; /* 不应到达这里 */
//}
//
///* 根据 ecap 值获取温度 */
//float get_temperature_by_ecap(uint32_t ecap) {
//    int i;
//    float temp;
//
//    /* 确保 ecap 值在合理范围内 */
//    if (ecap < table[0].ecapVal || ecap > table[TABLE_SIZE - 1].ecapVal) {
//        return -999.0f; /* 错误值 */
//    }
//
//    /* 遍历查找表 */
//    for (i = 0; i < TABLE_SIZE; i++) {
//        if (table[i].ecapVal == ecap) {
//            return table[i].tempVal;
//        }
//    }
//
//    /* 如果 ecap 值不在表中，返回最近的温度值 */
//    for (i = 0; i < TABLE_SIZE - 1; i++) {
//        if (ecap > table[i].ecapVal && ecap < table[i + 1].ecapVal) {
//            /* 线性插值 */
//            float delta_ecap = table[i + 1].ecapVal - table[i].ecapVal;
//            float delta_temp = table[i + 1].tempVal - table[i].tempVal;
//            temp = table[i].tempVal + (ecap - table[i].ecapVal) * delta_temp / delta_ecap;
//            return temp;
//        }
//    }
//
//    /* 如果超出表格范围，返回边界值 */
//    if (ecap <= table[0].ecapVal) {
//        return table[0].tempVal;
//    }
//    if (ecap >= table[TABLE_SIZE - 1].ecapVal) {
//        return table[TABLE_SIZE - 1].tempVal;
//    }
//
//    return -999.0f; /* 不应到达这里 */
//}
//
///*char转浮点，用于can/sci数据转换*/
////bytes：8位数组
////isFirst4Byte：前/后四位
////isBigEndian： 大/小字节序
////return：浮点结果
//float bytesToFloat(const uint8_t* bytes, bool isFirst4Byte, bool isBigEndian)
//{
//    union {
//        uint32_t i;
//        float f;
//    } u;
//
//    if (isFirst4Byte)
//    {
//        // 根据字节序处理字节
//        if (isBigEndian) {
//            u.i = (uint32_t)bytes[0] << 24 | (uint32_t)bytes[1] << 16 |
//                (uint32_t)bytes[2] << 8 | (uint32_t)bytes[3];
//        }
//        else
//        {
//            u.i = (uint32_t)bytes[3] << 24 | (uint32_t)bytes[2] << 16 |
//                (uint32_t)bytes[1] << 8 | (uint32_t)bytes[0];
//        }
//    }
//    else
//    {
//        if (isBigEndian) {
//            u.i = (uint32_t)bytes[4] << 24 | (uint32_t)bytes[5] << 16 |
//                (uint32_t)bytes[6] << 8 | (uint32_t)bytes[7];
//        }
//        else
//        {
//            u.i = (uint32_t)bytes[7] << 24 | (uint32_t)bytes[6] << 16 |
//                (uint32_t)bytes[5] << 8 | (uint32_t)bytes[4];
//        }
//    }
//
//    return u.f;
//}
//
//
//void floatToBytes(const float f, uint8_t* bytes, bool isBigEndian) {
//    union {
//        uint32_t i;
//        float f;
//    } u;
//
//    // 将浮点数赋值给联合体的浮点成员
//    u.f = f;
//
//    // 根据字节序将整数成员的值转换为字节序列
//    if (isBigEndian) {
//        bytes[0] = (uint8_t)(u.i >> 24);
//        bytes[1] = (uint8_t)(u.i >> 16);
//        bytes[2] = (uint8_t)(u.i >> 8);
//        bytes[3] = (uint8_t)u.i;
//    }
//    else {
//        bytes[3] = (uint8_t)(u.i >> 24);
//        bytes[2] = (uint8_t)(u.i >> 16);
//        bytes[1] = (uint8_t)(u.i >> 8);
//        bytes[0] = (uint8_t)u.i;
//    }
//}
//
///*二分法查找*/
//// arr[]: 数组
//// l: 查找范围的左边界
//// r: 查找范围的右边界
//// x: 要查找的元素
//// 如果找到元素，则返回元素的下标；如果未找到，则返回-1
//int binarySearch(int arr[], int l, int r, int x) {
//    while (l <= r) {
//        int m = l + (r - l) / 2;
//
//        if (arr[m] == x)
//            return m;
//
//        if (arr[m] > x)
//            r = m - 1;
//
//        else
//            l = m + 1;
//    }
//    return -1;
//}
//
//uint16_t CRC16_Modbus(uint8_t* _pBuf, uint16_t _usLen)
//{
//    uint8_t ucCRCHi = 0xFF; /* 高CRC字节初始化 */
//    uint8_t ucCRCLo = 0xFF; /* 低CRC 字节初始化 */
//    uint16_t usIndex;  /* CRC循环中的索引 */
//
//    while (_usLen--)
//    {
//        usIndex = ucCRCHi ^ *_pBuf++; /* 计算CRC */
//        ucCRCHi = ucCRCLo ^ s_CRCHi[usIndex];
//        ucCRCLo = s_CRCLo[usIndex];
//    }
//    return ((uint16_t)ucCRCHi << 8 | ucCRCLo);
//}
//
//int str_len(char* _str)
//{
//    int len = 0;
//
//    while (*_str++) len++;
//    return len;
//}
//
///*
//*********************************************************************************************************
//*   函 数 名: str_cpy
//*   功能说明: 复制字符串
//*   形    参: tar : 目标缓冲区
//*            src : 源缓冲区
//*   返 回 值: 无
//*********************************************************************************************************
//*/
//void str_cpy(char* _tar, char* _src)
//{
//    do
//    {
//        *_tar++ = *_src;
//    } while (*_src++);
//}
//
///*
//*********************************************************************************************************
//*   函 数 名: str_cmp
//*   功能说明: 字符串比较
//*   形    参: s1 : 字符串1
//*             s2 : 字符串2
//*   返 回 值: 0 表示相等 非0表示不等
//*********************************************************************************************************
//*/
//int str_cmp(char* s1, char* s2)
//{
//    while ((*s1 != 0) && (*s2 != 0) && (*s1 == *s2))
//    {
//        s1++;
//        s2++;
//    }
//    return *s1 - *s2;
//}
//
///*
//*********************************************************************************************************
//*   函 数 名: str_copy
//*   功能说明: 复制字符串
//*   形    参: tar : 目标缓冲区
//*            src : 源缓冲区
//*   返 回 值: 无
//*********************************************************************************************************
//*/
//void mem_set(char* _tar, char _data, int _len)
//{
//    while (_len--)
//    {
//        *_tar++ = _data;
//    }
//}
//
///*
//*********************************************************************************************************
//*   函 数 名: int_to_ascii
//*   功能说明: 将整数转换为ASCII数组。支持负数。
//*   形    参: _Number : 整数
//*            _pBuf : 目标缓冲区, 存放转换后的结果。以0结束的字符串。
//*            _len : ASCII字符个数, 字符串长度
//*   返 回 值: 无
//*********************************************************************************************************
//*/
//void int_to_str(int _iNumber, char* _pBuf, unsigned char _len)
//{
//    unsigned char i;
//    int iTemp;
//
//    if (_iNumber < 0)   /* 负数 */
//    {
//        iTemp = -_iNumber;  /* 转为正数 */
//    }
//    else
//    {
//        iTemp = _iNumber;
//    }
//
//    mem_set(_pBuf, ' ', _len);
//
//    /* 将整数转换为ASCII字符串 */
//    for (i = 0; i < _len; i++)
//    {
//        _pBuf[_len - 1 - i] = (iTemp % 10) + '0';
//        iTemp = iTemp / 10;
//        if (iTemp == 0)
//        {
//            break;
//        }
//    }
//    _pBuf[_len] = 0;
//
//    if (_iNumber < 0)   /* 负数 */
//    {
//        for (i = 0; i < _len; i++)
//        {
//            if ((_pBuf[i] == ' ') && (_pBuf[i + 1] != ' '))
//            {
//                _pBuf[i] = '-';
//                break;
//            }
//        }
//    }
//}
//
///*
//*********************************************************************************************************
//*   函 数 名: str_to_int
//*   功能说明: 将ASCII码字符串转换成整数。 遇到小数点自动越过。
//*   形    参: _pStr :待转换的ASCII码串. 可以以逗号，#或0结束。 2014-06-20 修改为非0-9的字符。
//*   返 回 值: 二进制整数值
//*********************************************************************************************************
//*/
//int str_to_int(char* _pStr)
//{
//    unsigned char flag;
//    char* p;
//    int ulInt;
//    unsigned char  i;
//    unsigned char  ucTemp;
//
//    p = _pStr;
//    if (*p == '-')
//    {
//        flag = 1;   /* 负数 */
//        p++;
//    }
//    else
//    {
//        flag = 0;
//    }
//
//    ulInt = 0;
//    for (i = 0; i < 15; i++)
//    {
//        ucTemp = *p;
//        if (ucTemp == '.')  /* 遇到小数点，自动跳过1个字节 */
//        {
//            p++;
//            ucTemp = *p;
//        }
//        if ((ucTemp >= '0') && (ucTemp <= '9'))
//        {
//            ulInt = ulInt * 10 + (ucTemp - '0');
//            p++;
//        }
//        else
//        {
//            break;
//        }
//    }
//
//    if (flag == 1)
//    {
//        return -ulInt;
//    }
//    return ulInt;
//}
//
///*
//*********************************************************************************************************
//*   函 数 名: BEBufToUint16
//*   功能说明: 将2字节数组(大端Big Endian次序，高字节在前)转换为16位整数
//*   形    参: _pBuf : 数组
//*   返 回 值: 16位整数值
//*
//*   大端(Big Endian)与小端(Little Endian)
//*********************************************************************************************************
//*/
//uint16_t BEBufToUint16(uint8_t* _pBuf)
//{
//    return (((uint16_t)_pBuf[0] << 8) | _pBuf[1]);
//}
//
///*
//*********************************************************************************************************
//*   函 数 名: LEBufToUint16
//*   功能说明: 将2字节数组(小端Little Endian，低字节在前)转换为16位整数
//*   形    参: _pBuf : 数组
//*   返 回 值: 16位整数值
//*********************************************************************************************************
//*/
//uint16_t LEBufToUint16(uint8_t* _pBuf)
//{
//    return (((uint16_t)_pBuf[1] << 8) | _pBuf[0]);
//}
//
//
///*
//*********************************************************************************************************
//*   函 数 名: BEBufToUint32
//*   功能说明: 将4字节数组(大端Big Endian次序，高字节在前)转换为16位整数
//*   形    参: _pBuf : 数组
//*   返 回 值: 16位整数值
//*
//*   大端(Big Endian)与小端(Little Endian)
//*********************************************************************************************************
//*/
//uint32_t BEBufToUint32(uint8_t* _pBuf)
//{
//    return (((uint32_t)_pBuf[0] << 24) | ((uint32_t)_pBuf[1] << 16) | ((uint32_t)_pBuf[2] << 8) | _pBuf[3]);
//}
//
///*
//*********************************************************************************************************
//*   函 数 名: LEBufToUint32
//*   功能说明: 将4字节数组(小端Little Endian，低字节在前)转换为16位整数
//*   形    参: _pBuf : 数组
//*   返 回 值: 16位整数值
//*********************************************************************************************************
//*/
//uint32_t LEBufToUint32(uint8_t* _pBuf)
//{
//    return (((uint32_t)_pBuf[3] << 24) | ((uint32_t)_pBuf[2] << 16) | ((uint32_t)_pBuf[1] << 8) | _pBuf[0]);
//}
//
//
///*
//*********************************************************************************************************
//*   函 数 名: CaculTwoPoint
//*   功能说明: 根据2点直线方程，计算Y值
//*   形    参:  2个点的坐标和x输入量
//*   返 回 值: x对应的y值
//*********************************************************************************************************
//*/
//int32_t  CaculTwoPoint(int32_t x1, int32_t y1, int32_t x2, int32_t y2, int32_t x)
//{
//    return y1 + ((int64_t)(y2 - y1) * (x - x1)) / (x2 - x1);
//}
//
//
///*
//*********************************************************************************************************
//*   函 数 名: BcdToChar
//*   功能说明: 将BCD码转为ASCII字符。 比如 0x0A ==> 'A'
//*   形    参: _bcd   ：输入的二进制数。必须小于16
//*   返 回 值: 转换结果
//*********************************************************************************************************
//*/
//char BcdToChar(uint8_t _bcd)
//{
//    if (_bcd < 10)
//    {
//        return _bcd + '0';
//    }
//    else if (_bcd < 16)
//    {
//        return _bcd + 'A';
//    }
//    else
//    {
//        return 0;
//    }
//}
//
///*
//*********************************************************************************************************
//*   函 数 名: HexToAscll
//*   功能说明: 将二进制数组转换为16进制格式的ASCII字符串。每个2个ASCII字符后保留1个空格。
//*             0x12 0x34 转化为 0x31 0x32 0x20 0x33 0x34 0x00  即 "1234"
//*   形    参:     _pHex   ：输入的数据，二进制数组
//*               _pAscii ：存放转换结果, ASCII字符串，0结束。1个二进制对应2个ASCII字符.
//*   返 回 值: 转换得到的整数
//*********************************************************************************************************
//*/
//void HexToAscll(uint8_t* _pHex, char* _pAscii, uint16_t _BinBytes)
//{
//    uint16_t i;
//
//    if (_BinBytes == 0)
//    {
//        _pAscii[0] = 0;
//    }
//    else
//    {
//        for (i = 0; i < _BinBytes; i++)
//        {
//            _pAscii[3 * i] = BcdToChar(_pHex[i] >> 4);
//            _pAscii[3 * i + 1] = BcdToChar(_pHex[i] & 0x0F);
//            _pAscii[3 * i + 2] = ' ';
//        }
//        _pAscii[3 * (i - 1) + 2] = 0;
//    }
//}
//
///*
//*********************************************************************************************************
//*   函 数 名: AsciiToUint32
//*   功能说明: 变长的 ASCII 字符转换为32位整数  ASCII 字符以空格或者0结束 。 支持16进制和10进制输入
//*   形    参: *pAscii ：要转换的ASCII码
//*   返 回 值: 转换得到的整数
//*********************************************************************************************************
//*/
//uint32_t AsciiToUint32(char* pAscii)
//{
//    char i;
//    char bTemp;
//    char bIsHex;
//    char bLen;
//    char bZeroLen;
//    uint32_t lResult;
//    uint32_t lBitValue;
//
//    /* 判断是否是16进制数 */
//    bIsHex = 0;
//    if ((pAscii[0] == '0') && ((pAscii[1] == 'x') || (pAscii[1] == 'X')))
//    {
//        bIsHex = 1;
//    }
//
//    lResult = 0;
//    // 最大数值为 4294967295, 10位+2字符"0x" //
//    if (bIsHex == 0)
//    { // 十进制 //
//        // 求长度 //
//        lBitValue = 1;
//
//        /* 前导去0 */
//        for (i = 0; i < 8; i++)
//        {
//            bTemp = pAscii[i];
//            if (bTemp != '0')
//                break;
//        }
//        bZeroLen = i;
//
//        for (i = 0; i < 10; i++)
//        {
//            if ((pAscii[i] < '0') || (pAscii[i] > '9'))
//                break;
//            lBitValue = lBitValue * 10;
//        }
//        bLen = i;
//        lBitValue = lBitValue / 10;
//        if (lBitValue == 0)
//            lBitValue = 1;
//        for (i = bZeroLen; i < bLen; i++)
//        {
//            lResult += (pAscii[i] - '0') * lBitValue;
//            lBitValue /= 10;
//        }
//    }
//    else
//    {   /* 16进制 */
//        /* 求长度 */
//        lBitValue = 1;
//
//        /* 前导去0 */
//        for (i = 0; i < 8; i++)
//        {
//            bTemp = pAscii[i + 2];
//            if (bTemp != '0')
//                break;
//        }
//        bZeroLen = i;
//        for (; i < 8; i++)
//        {
//            bTemp = pAscii[i + 2];
//            if (((bTemp >= 'A') && (bTemp <= 'F')) ||
//                ((bTemp >= 'a') && (bTemp <= 'f')) ||
//                ((bTemp >= '0') && (bTemp <= '9')))
//            {
//                lBitValue = lBitValue * 16;
//            }
//            else
//            {
//                break;
//            }
//        }
//        lBitValue = lBitValue / 16;
//        if (lBitValue == 0)
//            lBitValue = 1;
//        bLen = i;
//        for (i = bZeroLen; i < bLen; i++)
//        {
//            bTemp = pAscii[i + 2];
//            if ((bTemp >= 'A') && (bTemp <= 'F'))
//            {
//                bTemp -= 0x37;
//            }
//            else if ((bTemp >= 'a') && (bTemp <= 'f'))
//            {
//                bTemp -= 0x57;
//            }
//            else if ((bTemp >= '0') && (bTemp <= '9'))
//            {
//                bTemp -= '0';
//            }
//            lResult += bTemp * lBitValue;
//            lBitValue /= 16;
//        }
//    }
//    return lResult;
//}
//
//// 浮点数转定点数（8位整数，8位小数）
//uint16_t float_to_fixed_8_8(float value)
//{
//    // 先将浮点数四舍五入到最接近的SCALE_FACTOR分之一
//    float rounded_value = roundf(value * 0xff);
//
//    // 检查是否溢出，这里只检查正溢出，负溢出情况类似处理
//    if (rounded_value > (float)UINT16_MAX) {
//        // 处理溢出，可以根据需要调整
//        return UINT16_MAX;
//    }
//    else if (rounded_value < (float)INT16_MIN)
//    {
//        return 0;
//    }
//    return (uint16_t)rounded_value;
//}
//
//// 初始化滤波器
//void OptimizedMeanFilter10_Init(OptimizedMeanFilter10* filter)
//{
//    uint8_t i;
//    for (i = 0; i < 10; i++) {
//        filter->buffer[i] = 0;
//    }
//    filter->write_index = 0;
//    filter->current_sum = 0;  // 初始总和为0
//    filter->count = 0;
//    filter->is_full = 0;
//}
//
//// 添加新数据并更新总和
//void OptimizedMeanFilter10_Add(OptimizedMeanFilter10* filter, int32_t new_value) {
//    if (filter->is_full) {
//        // 缓冲区已满：减去即将被覆盖的旧数据
//        filter->current_sum -= filter->buffer[filter->write_index];
//    }
//
//    // 加上新数据并存储
//    filter->current_sum += new_value;
//    filter->buffer[filter->write_index] = new_value;
//
//    // 更新写入索引（循环覆盖）
//    filter->write_index = (filter->write_index + 1) % 10;
//
//    // 更新计数和满标志
//    if (!filter->is_full) {
//        filter->count++;
//        if (filter->count >= 10) {
//            filter->is_full = 1;
//        }
//    }
//}
//
//// 计算当前平均值（直接用维护的总和计算，无需重新累加）
//int32_t OptimizedMeanFilter10_Calculate(OptimizedMeanFilter10* filter) {
//    if (filter->count == 0) {
//        return 0;  // 无数据时返回0
//    }
//
//    // 根据实际数据量计算均值（未满时用count，满了用100）
//    uint8_t num_points = filter->is_full ? 10 : filter->count;
//    return (int32_t)(filter->current_sum / num_points);
//}
//
//// 生成在目标值±30范围内的随机数
//int getRandomWithOffset(int target) {
//    // 生成-30到30之间的随机偏移量
//    int offset = (rand() % 41) - 20;  // rand()%61生成0-60，减30后变为-30到30
//
//    // 返回目标值加上偏移量
//    return target + offset;
//}
//
//#if c_parabolic_prediction
//// 计算拟合误差，用于验证结果
//void solveLinearSystem(float A[3][3], float b[3], float x[3]) {
//    int i, j, k;
//    float temp, factor;
//
//    // 高斯消元
//    for (i = 0; i < 3; i++) {
//        // 寻找主元
//        int maxRow = i;
//        for (j = i + 1; j < 3; j++) {
//            if (fabs(A[j][i]) > fabs(A[maxRow][i])) {
//                maxRow = j;
//            }
//        }
//
//        // 交换行
//        if (maxRow != i) {
//            for (j = i; j < 3; j++) {
//                temp = A[i][j];
//                A[i][j] = A[maxRow][j];
//                A[maxRow][j] = temp;
//            }
//            temp = b[i];
//            b[i] = b[maxRow];
//            b[maxRow] = temp;
//        }
//
//        // 归一化主行
//        factor = A[i][i];
//        for (j = i; j < 3; j++) {
//            A[i][j] /= factor;
//        }
//        b[i] /= factor;
//
//        // 消去其他行
//        for (j = 0; j < 3; j++) {
//            if (j != i && A[j][i] != 0) {
//                factor = A[j][i];
//                for (k = i; k < 3; k++) {
//                    A[j][k] -= factor * A[i][k];
//                }
//                b[j] -= factor * b[i];
//            }
//        }
//    }
//
//    // 结果
//    for (i = 0; i < 3; i++) {
//        x[i] = b[i];
//    }
//}
//
//void findParabolaVertex(const float* x, const float* y, int n, float* vertexX, float* vertexY) {
//    // 至少需要3个点才能拟合抛物线
//    if (n < 3 || x == NULL || y == NULL || vertexX == NULL || vertexY == NULL) {
//        *vertexX = NAN;
//        *vertexY = NAN;
//        return;
//    }
//
//    // 计算最小二乘法所需的总和
//    float sumX = 0, sumX2 = 0, sumX3 = 0, sumX4 = 0;
//    float sumY = 0, sumXY = 0, sumX2Y = 0;
//    int i;
//    for (i = 0; i < n; i++) {
//        float xi = x[i];
//        float yi = y[i];
//        float xi2 = xi * xi;
//        float xi3 = xi2 * xi;
//        float xi4 = xi3 * xi;
//
//        sumX += xi;
//        sumX2 += xi2;
//        sumX3 += xi3;
//        sumX4 += xi4;
//        sumY += yi;
//        sumXY += xi * yi;
//        sumX2Y += xi2 * yi;
//    }
//
//    // 构建线性方程组 Ax = b，其中x = [a, b, c]^T
//    float A[3][3] = {
//        {sumX4, sumX3, sumX2},
//        {sumX3, sumX2, sumX},
//        {sumX2, sumX,   n}
//    };
//
//    float b[3] = { sumX2Y, sumXY, sumY };
//    float coeff[3]; // 存储a, b, c
//
//    // 求解方程组得到系数
//    solveLinearSystem(A, b, coeff);
//    float a = coeff[0];
//    float b_val = coeff[1];
//    float c = coeff[2];
//
//    // 计算顶点坐标
//    if (fabs(a) < 1e-10) {
//        // a接近0，不是抛物线
//        *vertexX = NAN;
//        *vertexY = NAN;
//    }
//    else {
//        *vertexX = -b_val / (2 * a);
//        *vertexY = a * (*vertexX) * (*vertexX) + b_val * (*vertexX) + c;
//    }
//}
//
///**
// * 生成带有噪声的抛物线采样点
// *
// * @param x 输出参数，存储生成的x坐标数组
// * @param y 输出参数，存储生成的y坐标数组（带有噪声）
// * @param numPoints 要生成的采样点数量
// * @param vertexX 抛物线顶点的x坐标
// * @param vertexY 抛物线顶点的y坐标
// * @param a 抛物线开口大小参数（a>0开口向上，a<0开口向下，绝对值越大开口越窄）
// * @param noiseLevel 噪声水平（0表示无噪声，值越大噪声越大）
// * @param xStart x坐标起始值
// * @param xEnd x坐标结束值
// */
//void generateNoisyParabola(float* x, float* y, int numPoints,
//    float vertexX, float vertexY, float a,
//    float noiseLevel, float xStart, float xEnd) {
//    if (numPoints <= 0 || x == NULL || y == NULL || xStart >= xEnd) {
//        return;
//    }
//
//    // 初始化随机数生成器
//    srand(time(NULL));
//
//    // 计算x步长
//    float step = (xEnd - xStart) / (numPoints - 1);
//    int i;
//    // 生成每个采样点
//    for (i = 0; i < numPoints; i++) {
//        // 生成x坐标
//        x[i] = xStart + i * step;
//
//        // 计算理想抛物线的y值 (顶点式: y = a(x - h)² + k)
//        float dx = x[i] - vertexX;
//        float idealY = a * dx * dx + vertexY;
//
//        // 生成噪声 (-noiseLevel 到 +noiseLevel 之间的随机值)
//        float noise = ((float)rand() / RAND_MAX) * 2 * noiseLevel - noiseLevel;
//
//        // 带噪声的y值
//        y[i] = idealY + noise;
//    }
//}
//#endif
//
